用 Go 编写一个 Composition 函数

  1package main
  2
  3import (
  4    "context"
  5
  6    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
  7    "k8s.io/utils/ptr"
  8
  9    "github.com/upbound/provider-aws/apis/s3/v1beta1"
 10
 11    "github.com/crossplane/function-sdk-go/errors"
 12    "github.com/crossplane/function-sdk-go/logging"
 13    fnv1beta1 "github.com/crossplane/function-sdk-go/proto/v1beta1"
 14    "github.com/crossplane/function-sdk-go/request"
 15    "github.com/crossplane/function-sdk-go/resource"
 16    "github.com/crossplane/function-sdk-go/resource/composed"
 17    "github.com/crossplane/function-sdk-go/response"
 18)
 19
 20// Function returns whatever response you ask it to.
 21type Function struct {
 22    fnv1beta1.UnimplementedFunctionRunnerServiceServer
 23
 24    log logging.Logger
 25}
 26
 27// RunFunction observes an XBuckets composite resource (XR). It adds an S3
 28// bucket to the desired state for every entry in the XR's spec.names array.
 29func (f *Function) RunFunction(_ context.Context, req *fnv1beta1.RunFunctionRequest) (*fnv1beta1.RunFunctionResponse, error) {
 30    f.log.Info("Running Function", "tag", req.GetMeta().GetTag())
 31
 32    // Create a response to the request. This copies the desired state and
 33    // pipeline context from the request to the response.
 34    rsp := response.To(req, response.DefaultTTL)
 35
 36    // Read the observed XR from the request. Most functions use the observed XR
 37    // to add desired managed resources.
 38    xr, err := request.GetObservedCompositeResource(req)
 39    if err != nil {
 40    	// If the function can't read the XR, the request is malformed. This
 41    	// should never happen. The function returns a fatal result. This tells
 42    	// Crossplane to stop running functions and return an error.
 43    	response.Fatal(rsp, errors.Wrapf(err, "cannot get observed composite resource from %T", req))
 44    	return rsp, nil
 45    }
 46
 47    // Create an updated logger with useful information about the XR.
 48    log := f.log.WithValues(
 49    	"xr-version", xr.Resource.GetAPIVersion(),
 50    	"xr-kind", xr.Resource.GetKind(),
 51    	"xr-name", xr.Resource.GetName(),
 52    )
 53
 54    // Get the region from the XR. The XR has getter methods like GetString,
 55    // GetBool, etc. You can use them to get values by their field path.
 56    region, err := xr.Resource.GetString("spec.region")
 57    if err != nil {
 58    	response.Fatal(rsp, errors.Wrapf(err, "cannot read spec.region field of %s", xr.Resource.GetKind()))
 59    	return rsp, nil
 60    }
 61
 62    // Get the array of bucket names from the XR.
 63    names, err := xr.Resource.GetStringArray("spec.names")
 64    if err != nil {
 65    	response.Fatal(rsp, errors.Wrapf(err, "cannot read spec.names field of %s", xr.Resource.GetKind()))
 66    	return rsp, nil
 67    }
 68
 69    // Get all desired composed resources from the request. The function will
 70    // update this map of resources, then save it. This get, update, set pattern
 71    // ensures the function keeps any resources added by other functions.
 72    desired, err := request.GetDesiredComposedResources(req)
 73    if err != nil {
 74    	response.Fatal(rsp, errors.Wrapf(err, "cannot get desired resources from %T", req))
 75    	return rsp, nil
 76    }
 77
 78    // Add v1beta1 types (including Bucket) to the composed resource scheme.
 79    // composed.From uses this to automatically set apiVersion and kind.
 80    _ = v1beta1.AddToScheme(composed.Scheme)
 81
 82    // Add a desired S3 bucket for each name.
 83    for _, name := range names {
 84    	// One advantage of writing a function in Go is strong typing. The
 85    	// function can import and use managed resource types from the provider.
 86    	b := &v1beta1.Bucket{
 87    		ObjectMeta: metav1.ObjectMeta{
 88    			// Set the external name annotation to the desired bucket name.
 89    			// This controls what the bucket will be named in AWS.
 90    			Annotations: map[string]string{
 91    				"crossplane.io/external-name": name,
 92    			},
 93    		},
 94    		Spec: v1beta1.BucketSpec{
 95    			ForProvider: v1beta1.BucketParameters{
 96    				// Set the bucket's region to the value read from the XR.
 97    				Region: ptr.To[string](region),
 98    			},
 99    		},
100    	}
101
102    	// Convert the bucket to the unstructured resource data format the SDK
103    	// uses to store desired composed resources.
104    	cd, err := composed.From(b)
105    	if err != nil {
106    		response.Fatal(rsp, errors.Wrapf(err, "cannot convert %T to %T", b, &composed.Unstructured{}))
107    		return rsp, nil
108    	}
109
110    	// Add the bucket to the map of desired composed resources. It's
111    	// important that the function adds the same bucket every time it's
112    	// called. It's also important that the bucket is added with the same
113    	// resource.Name every time it's called. The function prefixes the name
114    	// with "xbuckets-" to avoid collisions with any other composed
115    	// resources that might be in the desired resources map.
116    	desired[resource.Name("xbuckets-"+name)] = &resource.DesiredComposed{Resource: cd}
117    }
118
119    // Finally, save the updated desired composed resources to the response.
120    if err := response.SetDesiredComposedResources(rsp, desired); err != nil {
121    	response.Fatal(rsp, errors.Wrapf(err, "cannot set desired composed resources in %T", rsp))
122    	return rsp, nil
123    }
124
125    // Log what the function did. This will only appear in the function's pod
126    // logs. A function can use response.Normal and response.Warning to emit
127    // Kubernetes events associated with the XR it's operating on.
128    log.Info("Added desired buckets", "region", region, "count", len(names))
129
130    return rsp, nil
131}

  1package main
  2
  3import (
  4    "context"
  5    "testing"
  6    "time"
  7
  8    "github.com/google/go-cmp/cmp"
  9    "github.com/google/go-cmp/cmp/cmpopts"
 10    "google.golang.org/protobuf/testing/protocmp"
 11    "google.golang.org/protobuf/types/known/durationpb"
 12
 13    "github.com/crossplane/crossplane-runtime/pkg/logging"
 14
 15    fnv1beta1 "github.com/crossplane/function-sdk-go/proto/v1beta1"
 16    "github.com/crossplane/function-sdk-go/resource"
 17)
 18
 19func TestRunFunction(t *testing.T) {
 20    type args struct {
 21    	ctx context.Context
 22    	req *fnv1beta1.RunFunctionRequest
 23    }
 24    type want struct {
 25    	rsp *fnv1beta1.RunFunctionResponse
 26    	err error
 27    }
 28
 29    cases := map[string]struct {
 30    	reason string
 31    	args args
 32    	want want
 33    }{
 34    	"AddTwoBuckets": {
 35    		reason: "The Function should add two buckets to the desired composed resources",
 36    		args: args{
 37    			req: &fnv1beta1.RunFunctionRequest{
 38    				Observed: &fnv1beta1.State{
 39    					Composite: &fnv1beta1.Resource{
 40    						// MustStructJSON is a handy way to provide mock
 41    						// resources.
 42    						Resource: resource.MustStructJSON(`{
 43    							"apiVersion": "example.crossplane.io/v1alpha1",
 44    							"kind": "XBuckets",
 45    							"metadata": {
 46    								"name": "test"
 47    							},
 48    							"spec": {
 49    								"region": "us-east-2",
 50    								"names": [
 51    									"test-bucket-a",
 52    									"test-bucket-b"
 53    								]
 54    							}
 55    						}`),
 56    					},
 57    				},
 58    			},
 59    		},
 60    		want: want{
 61    			rsp: &fnv1beta1.RunFunctionResponse{
 62    				Meta: &fnv1beta1.ResponseMeta{Ttl: durationpb.New(60 * time.Second)},
 63    				Desired: &fnv1beta1.State{
 64    					Resources: map[string]*fnv1beta1.Resource{
 65    						"xbuckets-test-bucket-a": {Resource: resource.MustStructJSON(`{
 66    							"apiVersion": "s3.aws.upbound.io/v1beta1",
 67    							"kind": "Bucket",
 68    							"metadata": {
 69    								"annotations": {
 70    									"crossplane.io/external-name": "test-bucket-a"
 71    								}
 72    							},
 73    							"spec": {
 74    								"forProvider": {
 75    									"region": "us-east-2"
 76    								}
 77    							}
 78    						}`)},
 79    						"xbuckets-test-bucket-b": {Resource: resource.MustStructJSON(`{
 80    							"apiVersion": "s3.aws.upbound.io/v1beta1",
 81    							"kind": "Bucket",
 82    							"metadata": {
 83    								"annotations": {
 84    									"crossplane.io/external-name": "test-bucket-b"
 85    								}
 86    							},
 87    							"spec": {
 88    								"forProvider": {
 89    									"region": "us-east-2"
 90    								}
 91    							}
 92    						}`)},
 93    					},
 94    				},
 95    			},
 96    		},
 97    	},
 98    }
 99
100    for name, tc := range cases {
101    	t.Run(name, func(t *testing.T) {
102    		f := &Function{log: logging.NewNopLogger()}
103    		rsp, err := f.RunFunction(tc.args.ctx, tc.args.req)
104
105    		if diff := cmp.Diff(tc.want.rsp, rsp, protocmp.Transform()); diff != "" {
106    			t.Errorf("%s\nf.RunFunction(...): -want rsp, +got rsp:\n%s", tc.reason, diff)
107    		}
108
109    		if diff := cmp.Diff(tc.want.err, err, cmpopts.EquateErrors()); diff != "" {
110    			t.Errorf("%s\nf.RunFunction(...): -want err, +got err:\n%s", tc.reason, diff)
111    		}
112    	})
113    }
114}

 1apiVersion: example.crossplane.io/v1
 2kind: XBuckets
 3metadata:
 4  name: example-buckets
 5spec:
 6  region: us-east-2
 7  names:
 8  - crossplane-functions-example-a
 9  - crossplane-functions-example-b
10  - crossplane-functions-example-c

 1apiVersion: apiextensions.crossplane.io/v1
 2kind: Composition
 3metadata:
 4  name: create-buckets
 5spec:
 6  compositeTypeRef:
 7    apiVersion: example.crossplane.io/v1
 8    kind: XBuckets
 9  mode: Pipeline
10  pipeline:
11  - step: create-buckets
12    functionRef:
13      name: function-xbuckets

 1apiVersion: pkg.crossplane.io/v1beta1
 2kind: Function
 3metadata:
 4  name: function-xbuckets
 5  annotations:
 6    render.crossplane.io/runtime: Development
 7spec:
 8  # The CLI ignores this package when using the Development runtime.
 9  # You can set it to any value.
10  package: xpkg.upbound.io/negz/function-xbuckets:v0.1.0